// pages/sale-ticket-apply/sale-ticket-apply.js
const request = require('../../utils/request')

Page({

  /**
   * 页面的初始数据
   */
  data: {
    merchantId: '', // 商户ID
    merchantName: '',
    address: '',
    phone: '',
    // 商户搜索相关
    showSearchResults: false, // 控制搜索结果列表显示/隐藏
    merchantSearchKey: '',
    merchantSearchResults: [],
    merchantSearchPageNo: 1,
    merchantSearchPageSize: 10,
    merchantSearchTotal: 0,
    // 来源选择相关（商户角色进入时需要选择来源）
    showSourceSelector: false, // 显示来源选择弹窗
    sourceList: [], // 来源列表：[{ id, name }]，包含商户列表 + "我自己"
    selectedSourceIndex: 0, // 当前选中的来源索引
    selectedSourceId: '', // 当前选中的来源ID
    selectedSourceName: '', // 当前选中的来源名称
    customerId: '', // 申报人ID
    customerName: '', // 申报人姓名
    customerAddress: '', // 申请人地址
    customerAddressRegion: [], // 申请人地址省市区数组
    customerPhone: '', // 申请人手机号
    isLicens: true, // 已承诺达标，默认勾选
    isCheck: true, // 已通过检测，默认勾选
    remark: '', // 申报备注
    // 商品列表
    products: [{
      name: "",
      quantity: "",
      unit: "",
      goodsId: "" // 商品ID
    }],
    // 商品搜索相关
    showGoodsSearchResults: false, // 控制商品搜索结果显示
    goodsSearchResults: [], // 商品搜索结果
    activeGoodsIndex: -1, // 当前激活的商品索引
    goodsSearchTimer: null, // 商品搜索防抖定时器
    // 商户搜索相关
    activeMerchantSearch: false, // 是否激活商户搜索
    merchantSearchTimer: null, // 商户搜索防抖定时器
    // 地址选择相关
    addressList: [], // 地址列表（逗号分割后）
    showAddressSelector: false, // 显示地址选择器
    selectedAddressIndex: 0, // 当前选中的地址索引
    // 商户详情相关
    showMerchantDetail: false, // 显示商户详情弹窗
    merchantDetail: {}, // 商户详细信息
    // 预览模态框
    showPreview: false,
    // 仓位相关
    warehouseList: [], // 仓位列表
    warehouseName: '', // 当前选中的仓位名称
    selectedWarehouseIndex: 0, // 当前选中的仓位索引
    isFromScan: false // 是否来自扫码
  },
  // 添加商品
  addProduct() {
    const newProduct = {
      name: "",
      quantity: "",
      unit: "",
      goodsId: ""
    };
    const products = [...this.data.products, newProduct];
    this.setData({
      products
    });
  },
  // 删除商品
  deleteProduct(e) {
    const index = e.currentTarget.dataset.index;
    if (this.data.products.length <= 1) {
      wx.showToast({
        title: '至少保留一个商品',
        icon: 'none'
      });
      return;
    }
    const products = [...this.data.products];
    products.splice(index, 1);
    this.setData({
      products
    });
  },

  // 商品信息变化
  onProductChange(e) {
    const index = e.currentTarget.dataset.index;
    const field = e.currentTarget.dataset.field;
    const value = e.detail.value;

    const products = [...this.data.products];
    products[index][field] = value;
    this.setData({
      products
    });
  },
  // 备注输入
  onRemarkChange(e) {
    this.setData({ remark: e.detail.value })
  },
  // 申报人姓名修改
  onCustomerNameChange(e) {
    this.setData({ customerName: e.detail.value })
  },
  // 申请人地址省市区选择
  onCustomerAddressChange(e) {
    const region = e.detail.value || []
    const address = region.length ? region.join(' ') : ''
    this.setData({ 
      customerAddress: address,
      customerAddressRegion: region
    })
  },
  // 申请人手机号修改
  onCustomerPhoneChange(e) {
    this.setData({ customerPhone: e.detail.value })
  },
  // 切换复选框
  toggleCheckbox(e) {
    const field = e.currentTarget.dataset.field
    this.setData({
      [field]: !this.data[field]
    })
  },

  // 提交表单
  saveOrder() {
    const { merchantId, merchantName, isLicens, isCheck, products, remark, customerPhone } = this.data

    // 验证商户名称必填（必须是搜索选择的，通过 merchantId 判断）
    if (!merchantId) {
      wx.showToast({
        title: '请搜索并选择商户',
        icon: 'none'
      })
      return
    }

    // 验证申请人手机号必填
    if (!customerPhone || customerPhone.trim() === '') {
      wx.showToast({
        title: '请输入申请人手机号',
        icon: 'none'
      })
      return
    }

    // 验证手机号格式
    const phoneReg = /^1[3-9]\d{9}$/
    if (!phoneReg.test(customerPhone.trim())) {
      wx.showToast({
        title: '请输入正确的手机号',
        icon: 'none'
      })
      return
    }

    // 验证商品明细
    if (products.length === 0) {
      wx.showToast({
        title: '请至少添加一个商品',
        icon: 'none'
      })
      return
    }

    // 验证商品字段
    for (let i = 0; i < products.length; i++) {
      if (!products[i].name || !products[i].quantity) {
        wx.showToast({
          title: `请完善商品${i + 1}的信息`,
          icon: 'none'
        })
        return
      }
    }

      // 构造提交数据（包含商户信息、联系方式与商品明细、申报人信息）
    const submitData = {
      merchantId: merchantId,
        merchantName: this.data.merchantName,
        address: this.data.address,
        phone: this.data.phone,
        remark: remark,
      isLicens: isLicens,
      isCheck: isCheck,
      customerId: this.data.customerId, // 申报人ID
      customerName: this.data.customerName, // 申报人姓名
      customerAddress: this.data.customerAddress, // 申请人地址
      customerPhone: this.data.customerPhone, // 申请人手机号
      goodsSalesLicensDetailSaveReqVOS: products.map(item => ({
        prodName: item.name,
        prodCount: item.quantity,
        prodUnit: item.unit || '',
        goodsId: item.goodsId || '' // 商品ID（如果有搜索选择）
      }))
    }

    // 根据当前系统角色决定是否标记为商户代购
    // 若为商户角色：
    //  - 增加 is_merchant_buy: true 字段
    //  - 将申请人 ID(customerId) 设置为商户 ID（优先取登录时的 merchantId 缓存）
    try {
      const role = wx.getStorageSync('role') || ''
      if (role === 'merchant') {
        const globalMerchantId = wx.getStorageSync('merchantId') || merchantId || ''
        submitData.isMerchantBuy = true
        // 覆盖申请人ID为商户ID
        if (globalMerchantId) {
          submitData.customerId = globalMerchantId
        }
        // 如未显式传入申请人姓名，可使用商户名
        if (!submitData.customerName || submitData.customerName.trim() === '') {
          submitData.customerName = this.data.merchantName || submitData.customerName
        }
      }
    } catch (e) {
      // 读取缓存异常不应阻塞提交，静默处理
      console.warn('判断商户角色或读取 merchantId 失败', e)
    }

    wx.showLoading({
      title: '提交中...'
    })

    request.post('/admin-api/system/goods-sales-licens/create', submitData)
      .then(res => {
        wx.hideLoading()
        if (res.code === 0) {
          wx.showToast({
            title: '提交成功',
            icon: 'success'
          })
          // 主动触发上一页刷新（如果上一页实现了 loadApplications），然后返回
          try {
            const pages = getCurrentPages()
            if (pages && pages.length >= 2) {
              const prev = pages[pages.length - 2]
              if (prev && typeof prev.loadApplications === 'function') {
                prev.setData({ pageNo: 1, checkList: [] })
                prev.loadApplications(false).catch(() => {})
              }
            }
          } catch (e) {
            // ignore
          }
          setTimeout(() => {
            wx.navigateBack()
          }, 1200)
        }
      })
      .catch(err => {
        wx.hideLoading()
        console.error('提交失败:', err)
      })
  },

  // 返回上一页
  navigateBack() {
    wx.navigateBack()
  },

  // 阻止事件冒泡
  stopPropagation() {
    // 空函数，用于阻止点击预览内容时关闭模态框
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('页面加载参数:', options)
    
    // 获取并设置申报人信息（从本地存储读取登录用户信息）
    const userId = wx.getStorageSync('userId')
    const userName = wx.getStorageSync('userName')
    const role = wx.getStorageSync('role') || ''
    const merchantId = wx.getStorageSync('merchantId') || ''
    const storedMerchantName = wx.getStorageSync('merchantName') || ''
    
    // 判断是否为商户角色
    if (role === 'merchant') {
      // 商户角色：解析 merchantName 和 merchantId（都是逗号分隔的字符串）
      // 格式：merchantId = "id1,id2", merchantName = "商户1,商户2"
      // 构建来源选择列表：商户列表 + "我自己"
      const merchantNames = storedMerchantName ? storedMerchantName.split(',').map(name => name.trim()).filter(name => name) : []
      const merchantIds = merchantId ? merchantId.split(',').map(id => id.trim()).filter(id => id) : []
      const sourceList = []
      
      // 添加"我自己"选项（使用 userId）
      sourceList.push({
        id: userId || '',
        name: '我自己',
        isSelf: true
      })
      
      // 添加商户列表（merchantName 和 merchantId 一一对应）
      if (merchantNames.length > 0) {
        merchantNames.forEach((name, index) => {
          // 对应的商户ID（如果数量不匹配，使用第一个或空字符串）
          const correspondingId = merchantIds[index] || merchantIds[0] || ''
          sourceList.push({
            id: correspondingId,
            name: name,
            isSelf: false,
            merchantIndex: index
          })
        })
      }
      
      // 设置初始状态
      this.setData({
        customerId: userId || '',
        customerName: userName || '',
        sourceList: sourceList,
        selectedSourceIndex: -1, // 初始不选中，强制用户选择
        selectedSourceId: '',
        selectedSourceName: ''
      })
      
      // 如果有来源选项（包含"我自己" + 商户），显示选择弹窗
      // 延迟显示确保页面渲染完成
      if (sourceList.length > 0) {
        setTimeout(() => {
          this.setData({ showSourceSelector: true })
        }, 100)
      }
    } else {
      // 非商户角色：customerId 使用用户ID
      this.setData({
        customerId: userId || '',
        customerName: userName || ''
      })
      // 使用用户ID查询历史申请人信息
      this.loadLastApplicationInfo(userId)
    }
    
    // 处理扫码进入的情况
    // 新规则：URL参数中的 ad 字段直接是仓位地址
    // 示例：https://qts.ljtsc.cn?ad=北京市朝阳区测试仓位
    if (options.ad) {
      const warehouseAddress = decodeURIComponent(options.ad)
      console.log('扫码仓位地址:', warehouseAddress)
      
      // 标记为扫码进入，设置仓位地址
      this.setData({
        isFromScan: true,
        warehouseName: warehouseAddress,
        warehouseList: [],
        selectedWarehouseIndex: 0
      })
      
      // 调用 getByAddress 接口查询商户信息
      this.getMerchantInfoByAddress(warehouseAddress)
    }
    // 兼容旧版本：如果有 merchantId 参数，自动加载商户信息
    else if (options.merchantId) {
      const optionMerchantId = options.merchantId
      this.setData({ merchantId: optionMerchantId })
      this.getMerchantInfo(optionMerchantId)
    }
    // 否则等待用户手动搜索或扫码
  },

  // 加载最近一条申请记录的申请人信息
  // sourceId: 来源ID，可能是 userId（我自己）或 merchantId（商户）
  loadLastApplicationInfo(sourceId) {
    if (!sourceId) return
    
    // 判断当前选择的来源类型
    const { sourceList, selectedSourceIndex } = this.data
    const selectedSource = sourceList[selectedSourceIndex] || {}
    const isSelf = selectedSource.isSelf === true
    
    const params = {
      pageNo: 1,
      pageSize: 1
    }
    
    // 根据来源类型设置不同的查询参数
    if (isSelf) {
      // "我自己"：使用 customerId 查询
      params.customerId = sourceId
    } else {
      // 商户：使用 customerId 查询
      params.customerId = sourceId
    }
    console.log(params);
    
    request.get('/admin-api/system/goods-sales-licens/page', params)
      .then(res => {
        if (res.code === 0 && res.data) {
          const list = Array.isArray(res.data) ? res.data : (res.data.list || res.data.items || [])
          if (list.length > 0) {
            const firstRecord = list[0]
            // 回显申请人姓名、手机号、地址
            this.setData({
              customerName: firstRecord.customerName || this.data.customerName,
              customerPhone: firstRecord.customerPhone || '',
              customerAddress: firstRecord.customerAddress || ''
            })
          }
        }
      })
      .catch(err => {
        console.error('加载历史申请信息失败:', err)
        // 失败不影响正常使用，静默处理
      })
  },

  // 商户搜索输入（参考 createdetail 实现）
  onMerchantSearchInput(e) {
    const value = e.detail.value.trim()
    
    // 显示搜索结果
    this.setData({ 
      merchantSearchKey: value,
      activeMerchantSearch: true
    })

    // 清除之前的定时器
    if (this.data.merchantSearchTimer) {
      clearTimeout(this.data.merchantSearchTimer)
    }

    // 如果输入为空，清空搜索结果
    if (!value) {
      this.setData({ 
        merchantSearchResults: [],
        showSearchResults: false
      })
      return
    }

    // 设置防抖：300ms 后自动搜索
    const timer = setTimeout(() => {
      this.searchMerchants(value)
    }, 300)

    this.setData({ merchantSearchTimer: timer })
  },

  // 搜索商户（分页）
  searchMerchants(keyword) {
    if (!keyword) {
      this.setData({ 
        merchantSearchResults: [], 
        showSearchResults: false 
      })
      return
    }

    const params = {
      pageNo: 1,
      pageSize: 20,
      name: keyword
    }

    request.get('/admin-api/system/merchant-info/page', params)
      .then(res => {
        if (res.code === 0 && res.data) {
          const list = res.data.list || res.data.items || []
          if (list.length === 0) {
            wx.showToast({
              title: '商户搜索无结果',
              icon: 'none'
            })
          }
          this.setData({ 
            merchantSearchResults: list,
            showSearchResults: true
          })
        } else {
          this.setData({ 
            merchantSearchResults: [], 
            showSearchResults: true 
          })
        }
      })
      .catch(err => {
        console.error('商户搜索失败', err)
        this.setData({ 
          merchantSearchResults: [], 
          showSearchResults: false 
        })
        wx.showToast({ title: '搜索失败', icon: 'none' })
      })
  },

  // 扫描商家二维码（弹出选择：扫码 或 从相册选择）
  scanMerchantQRCode() {
    wx.showActionSheet({
      itemList: ['扫码', '从相册选择'],
      success: (res) => {
        if (res.tapIndex === 0) {
          // 扫码
          this.scanQRCodeFromCamera()
        } else if (res.tapIndex === 1) {
          // 从相册选择
          this.scanQRCodeFromAlbum()
        }
      },
      fail: (err) => {
        // 用户取消选择，不做处理
        console.log('用户取消选择', err)
      }
    })
  },

  // 从相机扫码
  scanQRCodeFromCamera() {
    wx.scanCode({
      onlyFromCamera: true,
      scanType: ['qrCode'],
      success: (res) => {
        this.handleScanResult(res.result)
      },
      fail: (err) => {
        console.error('扫描失败:', err)
        if (err.errMsg && err.errMsg.indexOf('cancel') === -1) {
          wx.showToast({
            title: '扫描失败',
            icon: 'none'
          })
        }
      }
    })
  },

  // 从相册选择二维码图片
  scanQRCodeFromAlbum() {
    wx.chooseImage({
      count: 1,
      sourceType: ['album'],
      success: (res) => {
        const imagePath = res.tempFilePaths[0]
        // 识别图片中的二维码
        wx.scanCode({
          onlyFromCamera: false,
          scanType: ['qrCode'],
          success: (scanRes) => {
            this.handleScanResult(scanRes.result)
          },
          fail: (err) => {
            console.error('识别二维码失败:', err)
            wx.showToast({
              title: '未识别到二维码',
              icon: 'none'
            })
          }
        })
      },
      fail: (err) => {
        console.log('用户取消选择图片', err)
      }
    })
  },

  // 处理扫码结果
  handleScanResult(result) {
    console.log('扫描结果:', result)
    
    try {
      // 新规则：解析 URL 参数格式
      // 示例：https://qts.ljtsc.cn?ad=北京市朝阳区测试仓位
      const scanResult = result
      
      // 检查是否包含 URL 参数
      if (scanResult.includes('?ad=')) {
        // 提取 ad 参数值
        const urlParts = scanResult.split('?ad=')
        if (urlParts.length === 2) {
          const warehouseAddress = decodeURIComponent(urlParts[1])
          console.log('扫码仓位地址:', warehouseAddress)
          
          // 设置仓位地址并标记为扫码方式
          this.setData({
            isFromScan: true,
            warehouseName: warehouseAddress,
            warehouseList: [],
            selectedWarehouseIndex: 0,
            showSearchResults: false,
            merchantSearchKey: '',
            merchantSearchResults: []
          })
          
          // 调用 getByAddress 接口查询商户信息
          this.getMerchantInfoByAddress(warehouseAddress)
        } else {
          wx.showToast({ title: '二维码格式错误', icon: 'none' })
        }
      }
      // 兼容旧格式：JSON 格式的二维码
      else if (scanResult.startsWith('{')) {
        const scanData = JSON.parse(scanResult)
        if (scanData.id) {
          // 先设置商户ID/名称/仓位（如果有），然后主动从后端获取完整商户信息以回显手机号/地址
          this.setData({
            merchantId: scanData.id,
            merchantName: scanData.name || this.data.merchantName || '',
            showSearchResults: false,
            merchantSearchKey: '',
            merchantSearchResults: [],
            isFromScan: true,
            warehouseName: scanData.address || scanData.warehouseName || scanData.warehouse || '名称',
            warehouseList: [],
            selectedWarehouseIndex: 0
          }, () => {
            // 调用仓位接口获取商户信息
            this.getMerchantAddress(scanData.id)
          })
          wx.showToast({ title: '商户信息已加载', icon: 'success' })
        } else {
          wx.showToast({ title: '二维码格式错误', icon: 'none' })
        }
      }
      else {
        wx.showToast({ title: '不支持的二维码格式', icon: 'none' })
      }
    } catch (err) {
      console.error('解析二维码失败:', err)
      wx.showToast({
        title: '二维码解析失败',
        icon: 'none'
      })
    }
  },

  // 选择商户后回填信息
  selectMerchant(e) {
    const item = e.currentTarget.dataset.item
    if (!item || !item.id) return
    
    // 选中后关闭搜索结果
    this.setData({ 
      merchantId: item.id,
      merchantName: item.name || '',
      showSearchResults: false,
      merchantSearchKey: '',
      merchantSearchResults: [],
      activeMerchantSearch: false,
      isFromScan: false // 手动搜索选择
    })
    this.getMerchantAddress(item.id)
  },
  
  // 隐藏商户搜索结果
  hideMerchantSearchResult() {
    this.setData({
      showSearchResults: false,
      merchantSearchResults: [],
      activeMerchantSearch: false
    })
  },

  // 地址选择相关方法
  onAddressChange(e) {
    const index = e.detail.value
    this.setData({
      selectedAddressIndex: index,
      address: this.data.addressList[index] || ''
    })
  },

  // 显示商户详情（调用 merchant-info/get 接口获取完整信息包括营业执照）
  showMerchantDetailModal() {
    if (!this.data.merchantId) {
      wx.showToast({
        title: '请先选择商户',
        icon: 'none'
      })
      return
    }
    
    wx.showLoading({ title: '加载中...' })
    
    request.get('/admin-api/system/merchant-info/get?id=' + this.data.merchantId)
      .then(res => {
        wx.hideLoading()
        if (res.code === 0 && res.data) {
          const merchantData = res.data
          const licenseStr = merchantData.businessLicense || merchantData.license || ''
          const licenseList = licenseStr ? licenseStr.split(/[,，]/).map(url => url.trim()).filter(url => url) : []
          
          this.setData({
            showMerchantDetail: true,
            merchantDetail: {
              name: merchantData.name || '',
              phone: merchantData.phone || '',
              address: merchantData.address || '',
              productCategory: merchantData.productCategory || merchantData.category || '',
              businessLicense: licenseStr,
              businessLicenseList: licenseList
            }
          })
        } else {
          // 接口返回失败，使用已有数据
          this.setData({ showMerchantDetail: true })
        }
      })
      .catch(err => {
        wx.hideLoading()
        console.error('获取商户详情失败:', err)
        // 请求失败，使用已有数据
        this.setData({ showMerchantDetail: true })
      })
  },

  // 关闭商户详情
  hideMerchantDetailModal() {
    this.setData({ showMerchantDetail: false })
  },

  // 预览营业执照
  previewBusinessLicense(e) {
    const licenseList = this.data.merchantDetail.businessLicenseList || []
    if (licenseList.length === 0) {
      wx.showToast({ title: '暂无营业执照', icon: 'none' })
      return
    }
    const index = e.currentTarget.dataset.index || 0
    wx.previewImage({
      current: licenseList[index],
      urls: licenseList
    })
  },

  // ========== 商品搜索相关方法 ==========
  // 商品搜索输入（参考 createdetail 实现）
  onGoodsSearchInput(e) {
    const index = e.currentTarget.dataset.index
    const value = e.detail.value.trim()
    
    // 显示搜索结果框
    this.setData({
      showGoodsSearchResults: true,
      activeGoodsIndex: index
    })

    // 清除之前的定时器
    if (this.data.goodsSearchTimer) {
      clearTimeout(this.data.goodsSearchTimer)
    }

    // 如果输入为空，清空搜索结果
    if (!value) {
      this.setData({ goodsSearchResults: [] })
      return
    }

    // 设置防抖：300ms 后自动搜索
    const timer = setTimeout(() => {
      this.searchGoods(value)
    }, 300)

    this.setData({ goodsSearchTimer: timer })
  },

  // 搜索商品
  searchGoods(keyword) {
    if (!keyword) {
      this.setData({ goodsSearchResults: [] })
      return
    }

    const params = { keyword }

    request.get('/admin-api/system/goods-info/getList', params)
      .then(res => {
        if (res.code === 0 && res.data) {
          const list = Array.isArray(res.data) ? res.data : (res.data.list || res.data.items || [])
          if (list.length === 0) {
            wx.showToast({
              title: '商品搜索无结果',
              icon: 'none'
            })
          }
          this.setData({
            goodsSearchResults: list
          })
        } else {
          this.setData({ goodsSearchResults: [] })
        }
      })
      .catch(err => {
        console.error('商品搜索失败', err)
        this.setData({ goodsSearchResults: [] })
        wx.showToast({ title: '搜索失败', icon: 'none' })
      })
  },

  // 选择商品
  selectGoods(e) {
    const item = e.currentTarget.dataset.item
    const { activeGoodsIndex } = this.data
    
    // 验证索引是否有效
    if (activeGoodsIndex === -1 || activeGoodsIndex >= this.data.products.length) {
      console.error('无效的商品索引:', activeGoodsIndex)
      return
    }

    const products = [...this.data.products]
    products[activeGoodsIndex] = {
      ...products[activeGoodsIndex],
      goodsId: item.id,
      name: item.name,
      unit: item.unit || ''
    }

    this.setData({
      products,
      showGoodsSearchResults: false,
      goodsSearchResults: [],
      activeGoodsIndex: -1
    })
  },
  
  // 隐藏商品搜索结果
  hideGoodsSearchResult() {
    this.setData({
      showGoodsSearchResults: false,
      goodsSearchResults: [],
      activeGoodsIndex: -1
    })
  },

  // ========== 商户搜索相关方法 ==========
  // 根据仓位地址获取商户信息（扫码场景）
  getMerchantInfoByAddress(address) {
    if (!address) {
      wx.showToast({
        title: '仓位地址为空',
        icon: 'none'
      })
      return
    }
    
    wx.showLoading({
      title: '加载商户信息...'
    })
    
    request.get('/admin-api/system/merchant-address/getByAddress', {
      address: address
    })
      .then(res => {
        wx.hideLoading()
        if (res.code === 0 && res.data) {
          const data = res.data
          
          // 设置商户基本信息
          const merchantName = data.merchantName || data.name || ''
          const merchantPhone = data.merchantPhone || data.phone || ''
          const merchantAddress = data.merchantAddress || data.address || address
          const merchantId = data.merchantId || data.id || ''
          
          // 处理营业执照URL（支持多张图片，逗号分隔）
          const licenseStr = data.businessLicense || data.license || ''
          const licenseList = licenseStr ? licenseStr.split(/[,，]/).map(url => url.trim()).filter(url => url) : []
          
          this.setData({
            merchantId: merchantId,
            merchantName: merchantName,
            address: merchantAddress,
            phone: merchantPhone,
            merchantDetail: {
              name: merchantName,
              phone: merchantPhone,
              address: merchantAddress,
              productCategory: data.productCategory || data.category || '',
              businessLicense: licenseStr,
              businessLicenseList: licenseList
            }
          })
          
          wx.showToast({
            title: '商户信息已加载',
            icon: 'success'
          })
        } else {
          wx.showToast({
            title: res.msg || '获取商户信息失败',
            icon: 'none'
          })
        }
      })
      .catch(err => {
        wx.hideLoading()
        console.error('根据仓位获取商户信息失败:', err)
        wx.showToast({
          title: '获取商户信息失败',
          icon: 'none'
        })
      })
  },
  
  // 获取商户仓位数据和商户信息
  getMerchantAddress(merchantId) {
    wx.showLoading({
      title: '加载中...'
    })

    const params = {
      merchantId: merchantId,
      pageNo: 1,
      pageSize: 100 // 获取所有仓位
    }
    
    request.get('/admin-api/system/merchant-address/page', params)
      .then(res => {
        wx.hideLoading()
        if (res.code === 0 && res.data) {
          const list = Array.isArray(res.data) ? res.data : (res.data.list || res.data.records || [])
          
          // 如果有数据，使用第一条数据回显商户信息
          if (list.length > 0) {
            const firstData = list[0]
            const addressStr = firstData.merchantAddress || firstData.address || ''
            const merchantPhone = firstData.merchantPhone || firstData.phone || ''
            const merchantName = firstData.merchantName || firstData.name || this.data.merchantName
            
            // 判断地址是否包含逗号（多个地址）
            const addressList = addressStr.includes(',') || addressStr.includes('，') 
              ? addressStr.split(/[,，]/).map(addr => addr.trim()).filter(addr => addr)
              : [addressStr]
            
            // 处理营业执照URL（支持多张图片，逗号分隔）
            const licenseStr = firstData.businessLicense || firstData.license || ''
            const licenseList = licenseStr ? licenseStr.split(/[,，]/).map(url => url.trim()).filter(url => url) : []
            
            // 处理仓位列表
            const warehouseList = list.map(item => item.name || item.address || '').filter(name => name)
            
            // 扫码情况：使用扫码时已设置的warehouseName，不覆盖
            // 手动选择：使用第一条数据的仓位名称
            const setWarehouseName = this.data.isFromScan ? this.data.warehouseName : (warehouseList[0] || '')
            
            this.setData({
              merchantName: merchantName,
              addressList: addressList,
              address: addressList[0] || '', // 默认选中第一个地址
              selectedAddressIndex: 0,
              phone: merchantPhone,
              merchantDetail: {
                name: merchantName,
                phone: merchantPhone,
                address: addressStr,
                productCategory: firstData.productCategory || firstData.category || '',
                businessLicense: licenseStr,
                businessLicenseList: licenseList
              },
              warehouseList: this.data.isFromScan ? [] : warehouseList,
              warehouseName: setWarehouseName,
              selectedWarehouseIndex: 0
            })
            
            // 如果有多个地址，提示用户选择
            if (addressList.length > 1) {
              wx.showToast({
                title: '检测到多个地址，请选择',
                icon: 'none'
              })
            }
            
            // 如果有多个仓位且非扫码，提示用户选择
            if (!this.data.isFromScan && warehouseList.length > 1) {
              wx.showToast({
                title: '检测到多个仓位，请选择',
                icon: 'none'
              })
            }
          }
        }
      })
      .catch(err => {
        wx.hideLoading()
        console.error('获取商户信息失败:', err)
        wx.showToast({
          title: '获取商户信息失败',
          icon: 'none'
        })
      })
  },

  // 仓位选择变化
  onWarehouseChange(e) {
    const index = e.detail.value
    this.setData({
      selectedWarehouseIndex: index,
      warehouseName: this.data.warehouseList[index] || ''
    })
  },

  // ========== 来源选择相关方法（商户角色） ==========
  // 选择来源项
  selectSource(e) {
    const index = e.currentTarget.dataset.index
    this.setData({ selectedSourceIndex: index })
  },

  // 确认来源选择
  confirmSourceSelection() {
    const { sourceList, selectedSourceIndex } = this.data
    
    // 检查是否已选择
    if (selectedSourceIndex < 0 || selectedSourceIndex >= sourceList.length) {
      wx.showToast({ title: '请选择来源', icon: 'none' })
      return
    }
    
    const selectedSource = sourceList[selectedSourceIndex]
    const userId = wx.getStorageSync('userId') || ''
    // 优先使用 role 接口返回的 name（roleName），其次使用 userName
    const roleName = wx.getStorageSync('roleName') || wx.getStorageSync('userName') || ''
    
    // 根据选择的来源设置申请人信息
    if (selectedSource.isSelf) {
      // 选择"我自己"：使用用户ID和role接口返回的name
      this.setData({
        selectedSourceId: selectedSource.id,
        selectedSourceName: selectedSource.name,
        showSourceSelector: false,
        customerId: userId,
        customerName: roleName
      })
    } else {
      // 选择商户：使用商户ID和商户名
      this.setData({
        selectedSourceId: selectedSource.id,
        selectedSourceName: selectedSource.name,
        showSourceSelector: false,
        customerId: selectedSource.id,
        customerName: selectedSource.name
      })
    }
    
    // 根据选择的来源 ID 加载最近一条申请记录（回填手机号、地址等）
    this.loadLastApplicationInfo(selectedSource.id)
  },

  // 关闭来源选择弹窗（必须选择才能关闭）
  hideSourceSelector() {
    const { selectedSourceIndex, sourceList } = this.data
    
    // 如果还没有选择，提示用户必须选择
    if (selectedSourceIndex < 0) {
      wx.showToast({ title: '请先选择来源', icon: 'none' })
      return
    }
    
    // 已选择，关闭弹窗并设置申请人信息
    const selectedSource = sourceList[selectedSourceIndex]
    const userId = wx.getStorageSync('userId') || ''
    // 优先使用 role 接口返回的 name（roleName），其次使用 userName
    const roleName = wx.getStorageSync('roleName') || wx.getStorageSync('userName') || ''
    
    if (selectedSource.isSelf) {
      // 选择"我自己"：使用用户ID和role接口返回的name
      this.setData({
        selectedSourceId: selectedSource.id,
        selectedSourceName: selectedSource.name,
        showSourceSelector: false,
        customerId: userId,
        customerName: roleName
      })
    } else {
      // 选择商户：使用商户ID和商户名
      this.setData({
        selectedSourceId: selectedSource.id,
        selectedSourceName: selectedSource.name,
        showSourceSelector: false,
        customerId: selectedSource.id,
        customerName: selectedSource.name
      })
    }
    
    this.loadLastApplicationInfo(selectedSource.id)
  },

  // 点击来源标签，重新显示选择弹窗
  showSourceSelectorModal() {
    if (this.data.sourceList.length > 0) {
      this.setData({ showSourceSelector: true })
    }
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  }
})